// 检查登录状态
import Taro from '@tarojs/taro';
import { UserInfoPreset } from './presets';
import { getUserInfo } from '../api/user';
import { getCarLicensesApi } from '../api/baseApi';
import { API_BASE_URL, generateRandomString } from '../utils/common';
import { UserRole } from '../types/user';

// 导出单独的checkLoginStatus函数，保持向后兼容
export const checkLoginStatus = (): boolean => {
  try {
    const env = Taro.getEnv();
    let token = '';
    try {
      if (env === Taro.ENV_TYPE.WEB && typeof window !== 'undefined' && window.localStorage) {
        token = localStorage.getItem('access_token') || '';
      } else if (Taro && typeof Taro.getStorageSync === 'function') {
        token = Taro.getStorageSync('access_token') || '';
      }
    } catch (error) {
      console.error('获取token失败:', error);
      // 降级方案：尝试直接使用localStorage
      try {
        if (typeof window !== 'undefined') {
          token = localStorage.getItem('access_token') || '';
        }
      } catch (innerError) {
        console.error('降级方案也失败:', innerError);
      }
    }
    console.log("获取token:", !!token)
    return !!token;
  } catch (error) {
    console.error('检查登录状态失败:', error);
    return false;
  }
};

/**
 * 设置token到存储，兼容不同环境
 */
export const setToken = (token: string): void => {
  try {
    const env = Taro.getEnv();
    if (env === Taro.ENV_TYPE.WEB  && typeof window !== 'undefined' && window.localStorage) {
      localStorage.setItem('access_token', token);
    } else if (Taro && typeof Taro.setStorageSync === 'function') {
      Taro.setStorageSync('access_token', token);
    }
  } catch (error) {
    console.error('设置token失败:', error);
  }
};

/**
 * 从存储获取token，兼容不同环境
 */
export const getToken = (): string => {
  try {
    const env = Taro.getEnv();
    if (env === Taro.ENV_TYPE.WEB && typeof window !== 'undefined' && window.localStorage) {
      return localStorage.getItem('access_token') || '';
    } else if (Taro && typeof Taro.getStorageSync === 'function') {
      return Taro.getStorageSync('access_token') || '';
    }
    return '';
  } catch (error) {
    console.error('获取token失败:', error);
    return '';
  }
};

/**
 * 移除存储中的token，兼容不同环境
 * @param setUserInfo 可选参数，用于重置用户信息
 */
export const removeToken = (setUserInfo?: (userInfo: any) => void) => {
  try {
    const env = Taro.getEnv();
    if (env === Taro.ENV_TYPE.WEB && typeof window !== 'undefined' && window.localStorage) {
      localStorage.removeItem('access_token');
    } else if (Taro && typeof Taro.removeStorageSync === 'function') {
      Taro.removeStorageSync('access_token');
    }
    
    // 如果提供了setUserInfo，则重置用户信息
    if (setUserInfo) {
      setUserInfo(UserInfoPreset);
    }
  } catch (error) {
    console.error('移除token失败:', error);
  }
};

/**
 * 检查用户状态
 * @param userInfo 当前用户信息
 * @param setUserInfo 设置用户信息的函数
 * @returns 是否成功刷新用户信息或用户信息有效
 */
export const checkUserStatus = async (userInfo: any, setUserInfo?: (userInfo: any) => void) => {
  try {
    const token = getToken();
    if (!token) {
      console.log("检查用户状态：无token");
      if (setUserInfo) {
        setUserInfo(UserInfoPreset);
      }
      return false;
    }
    // 检查用户信息是否有效（已登录）
    const now = new Date();
    let isExpire = false;
    
    try {
      // 检查用户信息是否过期（30分钟）
      if (now.getTime() - (userInfo?.updateTime || 0) > 1000 * 60 * 30) {
        isExpire = true;
        console.log("检查用户状态：用户信息已过期");
      } else {
        console.log("检查用户状态：用户信息有效，未过期");
        return true; // 用户信息有效且未过期，直接返回true
      }
    } catch {
      isExpire = true;
      console.log("检查用户状态：用户信息时间校验异常，视为过期");
    }

    if (isExpire && setUserInfo) {
      console.log("检查用户状态：尝试刷新用户信息");
      return await getUserInfo().then((userInfoResponse) => {
        if (userInfoResponse.code === 200 && userInfoResponse.data) {
          console.log("更新用户信息结果");
          setUserInfo({ ...userInfoResponse.data, updateTime: now.getTime() });
          return true;
        }else{
          removeToken(setUserInfo);
        }
      }).catch(err => {
        console.log("检查用户状态：尝试刷新用户信息失败");
        return false    
      })
    }
  } catch (error) {
    console.error('检查用户状态失败:', error);
    return false;
  }
}

export const appStartCheckUserInfo = async (userInfo, setUserInfo) => {
  console.log('App 启动检查...')
  try {
    const token = getToken();
    if (!token) {
      console.log("App 启动检查:无token");
      return false;
    }
    // 正确等待 checkUserStatus 完成并返回结果
    const result = await checkUserStatus(userInfo, setUserInfo);
    console.log('驾照易考通小程序启动检查结果', result);
    return result;
  }catch (error) {
    console.error('App 启动检查失败:', error);
    return false;
  }
}

export const getInitDataStore = async (setCarLicenseList) => {
  await getCarLicensesApi().then((resp) => {
    if (resp.code === 200 && resp.data) {
      setCarLicenseList(resp.data);
    }
  }).catch(err => {
    console.log("获取车辆执照数据失败");
  })
}

export const routerBack = (userInfo: any) => {
  try {
    // 添加防抖逻辑，避免短时间内重复导航
    if (routerBack._lastCallTime && Date.now() - routerBack._lastCallTime < 500) {
      console.log('导航操作过于频繁，已忽略');
      return;
    }
    routerBack._lastCallTime = Date.now();

    const pages = Taro.getCurrentPages();
    console.log('当前页面栈:', pages);
    
    // 获取用户角色，如果没有提供userInfo则从存储中获取
    const userRole = userInfo?.role || UserRole.GUEST;
    console.log('userRole:', userRole, UserRole.COACH);
    
    // 导航到目标页面的函数，包含错误处理
    const navigateToPage = (url: string, type: 'navigate' | 'switchTab' = 'navigate') => {
      try {
        // 设置超时处理
        const timeoutId = setTimeout(() => {
          console.error(`导航到${url}超时，尝试替代方案`);
          // 超时后使用switchTab到首页作为兜底方案
          Taro.switchTab({
            url: '/pages/index/index',
            fail: (err) => console.error('兜底导航失败:', err)
          });
        }, 3000); // 3秒超时

        const navOptions = {
          url,
          success: () => {
            clearTimeout(timeoutId);
            console.log(`成功导航到${url}`);
          },
          fail: (err) => {
            clearTimeout(timeoutId);
            console.error(`导航失败到${url}:`, err);
            // 失败后尝试使用switchTab到首页
            Taro.switchTab({
              url: '/pages/index/index',
              fail: (innerErr) => console.error('兜底导航失败:', innerErr)
            });
          }
        };

        if (type === 'switchTab') {
          Taro.switchTab(navOptions);
        } else {
          Taro.navigateTo(navOptions);
        }
      } catch (error) {
        console.error('导航异常:', error);
        // 异常情况下直接跳转到首页
        Taro.switchTab({
          url: '/pages/index/index'
        });
      }
    };

    // 根据用户角色进行不同的路由处理
    if (userRole === UserRole.COACH) {
      // 教练角色，跳转到教练中心
      navigateToPage('/pages/coach-center/index');
    } else if (userRole === UserRole.STAFF) {
      // 职员角色，跳转到职员中心
      navigateToPage('/pages/staff-center/index');
    } else if (userRole === UserRole.GUEST) {
      // 游客角色，需要登录
      navigateToPage('/pages/login/index');
    } else {
      // 普通用户角色
      if (pages && pages.length > 1) {
        try {
          const lastPage = pages[pages.length - 1];
          if (lastPage && lastPage.route === '/pages/login/index') {
            navigateToPage('/pages/index/index', 'switchTab');
          } else {
            // 先尝试返回上一页
            const backTimeoutId = setTimeout(() => {
              console.error('返回上一页超时，跳转到首页');
              navigateToPage('/pages/index/index', 'switchTab');
            }, 2000);
            
            Taro.navigateBack({
              delta: 1,
              success: () => {
                clearTimeout(backTimeoutId);
                console.log('成功返回上一页');
              },
              fail: (err) => {
                clearTimeout(backTimeoutId);
                console.error('返回上一页失败:', err);
                navigateToPage('/pages/index/index', 'switchTab');
              }
            });
          }
        } catch (error) {
          console.error('页面栈操作异常:', error);
          navigateToPage('/pages/index/index', 'switchTab');
        }
      } else {
        navigateToPage('/pages/index/index', 'switchTab');
      }
    }
  } catch (error) {
    console.error('routerBack函数执行异常:', error);
    // 最外层错误捕获，确保至少能导航到首页
    Taro.switchTab({
      url: '/pages/index/index'
    });
  }
};

// 为routerBack函数添加静态属性用于防抖
routerBack._lastCallTime = 0;


export const userLoginLimit = (content: string = "获取内容，请登录服务", userInfo: any = null) => {
  const user_token = getToken();
  console.log("userLoginLimit:", user_token?1:0)
  if (!user_token) {
    Taro.showModal({
      title: '温馨提示',
      content: content,
      showCancel: true,
      success: (res) => {
        if (res.confirm) {
          Taro.navigateTo({
            url: '/pages/login/index',
          });
        }else{
          routerBack(userInfo);
        }
      }
    });
    return false
  }
  return true;
}


export const coachRoleLimit = (content: string = "获取内容，请登录服务", userInfo: any = null) => {
  if (!getToken() || userInfo?.role !== UserRole.COACH) {
    Taro.showModal({
      title: '温馨提示',
      content: content,
      showCancel: true,
      success: (res) => {
        if (res.confirm) {
          Taro.navigateTo({
            url: '/pages/login/index',
          });
        }else{
          routerBack(userInfo);
        }
      }
    });
    return false
  }
  return true;
}


// 上传用户文件
export const uploadUserFile = (filePath: string, fileName: string, fileType: string, target: string, user_id: number | string) => {
  return new Promise((resolve, reject) => {
    Taro.uploadFile({
      url: API_BASE_URL + '/api/common/v1/file', 
      filePath: filePath,
      name: 'file',
      header: {
        'content-type': 'multipart/form-data',
        'X-Auth-token': getToken(),
        'X-Auth-version': '1.0',
        'X-Auth-signature': generateRandomString(16),
        'X-Auth-timestamp': Date.now().toString()
      },
      formData: {
        'target': target,
        'file_type': fileType,
        'file_name': fileName,
        'user_id': user_id,
      },
      success: (res) => {
        try {
          const data = JSON.parse(res.data);
          return resolve(data);
        } catch (error) {
          reject('文件上传失败，请重试');
        }
      },
      fail: (err) => {
        reject('文件上传失败，请重试');
      }
    })
  })
}
